68 research outputs found
Graph Based Reduction of Program Verification Conditions
Increasing the automaticity of proofs in deductive verification of C programs
is a challenging task. When applied to industrial C programs known heuristics
to generate simpler verification conditions are not efficient enough. This is
mainly due to their size and a high number of irrelevant hypotheses. This work
presents a strategy to reduce program verification conditions by selecting
their relevant hypotheses. The relevance of a hypothesis is determined by the
combination of a syntactic analysis and two graph traversals. The first graph
is labeled by constants and the second one by the predicates in the axioms. The
approach is applied on a benchmark arising in industrial program verification
Opportunities for a Truffle-based Golo Interpreter
Golo is a simple dynamically-typed language for the Java Virtual Machine.
Initially implemented as a ahead-of-time compiler to JVM bytecode, it leverages
invokedy-namic and JSR 292 method handles to implement a reasonably efficient
runtime. Truffle is emerging as a framework for building interpreters for JVM
languages with self-specializing AST nodes. Combined with the Graal compiler,
Truffle offers a simple path towards writing efficient interpreters while
keeping the engineering efforts balanced. The Golo project is interested in
experimenting with a Truffle interpreter in the future, as it would provides
interesting comparison elements between invokedynamic versus Truffle for
building a language runtime
Syntactic Abstraction of B Models to Generate Tests
In a model-based testing approach as well as for the verification of
properties, B models provide an interesting solution. However, for industrial
applications, the size of their state space often makes them hard to handle. To
reduce the amount of states, an abstraction function can be used, often
combining state variable elimination and domain abstractions of the remaining
variables. This paper complements previous results, based on domain abstraction
for test generation, by adding a preliminary syntactic abstraction phase, based
on variable elimination. We define a syntactic transformation that suppresses
some variables from a B event model, in addition to a method that chooses
relevant variables according to a test purpose. We propose two methods to
compute an abstraction A of an initial model M. The first one computes A as a
simulation of M, and the second one computes A as a bisimulation of M. The
abstraction process produces a finite state system. We apply this abstraction
computation to a Model Based Testing process.Comment: Tests and Proofs 2010, Malaga : Spain (2010
Towards a Decoupled Context-Oriented Programming Language for the Internet of Things
Easily programming behaviors is one major issue of a large and reconfigurable
deployment in the Internet of Things. Such kind of devices often requires to
externalize part of their behavior such as the sensing, the data aggregation or
the code offloading. Most existing context-oriented programming languages
integrate in the same class or close layers the whole behavior. We propose to
abstract and separate the context tracking from the decision process, and to
use event-based handlers to interconnect them. We keep a very easy declarative
and non-layered programming model. We illustrate by defining an extension to
Golo-a JVM-based dynamic language
Vérification de propriétés LTL sur des programmes C par génération d'annotations
Ce travail propose une méthode de vérification de propriétés temporelles basée sur la génération automatique d'annotations de programmes. Les annotations générées sont ensuite vérifiées par des prouveurs automatiques via un calcul de plus faible précondition. Notre contribution vise à optimiser une technique existante de génération d'annotations, afin d'améliorer l'automatisation de la vérification des obligations de preuve produites. Cette approche a été outillée sous la forme d'un plugin au sein de l'outil Frama-C pour la vérification de programmes~
OSGiLarva : a monitoring framework supporting OSGi’s dynamicity
Service-Oriented Architecture is an approach
where software systems are designed in terms of a composition
of services. OSGi is a Service-Oriented Framework dedicated
to 24/7 Java systems. In this Service-Oriented Programming
approach, software is composed of services that may dynamically appear or disappear. In such a case, classical monitoring
approaches with statically injected monitors into services
cannot be used. In this paper, we describe ongoing work
proposing a dynamic monitoring approach dedicated to local
SOA systems, focusing particularly on OSGi. Firstly, we define
two key properties of loosely coupled monitoring systems:
dynamicity resilience and comprehensiveness. Next, we propose
the OSGiLarva tool, which is a preliminary implementation
targeted at the OSGi framework. Finally, we present some
quantitative results showing that a dynamic monitor based
on dynamic proxies and another based on aspect-oriented
programming have equivalent performances.peer-reviewe
Le Libre : catalyseur de l'Humanisme ?
National audienceL'ingénieur humaniste doit comprendre le monde et œuvrer à la diffusion large et sans barrières ni discrimination de la connaissance. Ce concept résonne largement avec celui de la culture libre, qui promeut la liberté de distribution des biens non matériels tels que logiciels, inventions, connaissances, etc.. Nous défendons donc dans cette communication que la sensibilisation à la culture libre est à la fois une opportunité et une nécessité pour la formation d'ingénieurs humanistes. Nous proposons également quelques pistes de réflexion pour l'intégration de cette culture libre dans notre contexte
B Model Slicing and Predicate Abstraction to Generate Tests
Accepted manuscript. Revised and extended version of a TAP'10 paper. To appear.International audienceIn a model-based testing approach as well as for the verification of properties, B models provide an interesting modeling solution. However, for industrial applications, the size of their state space often makes them hard to handle. To reduce the amount of states, an abstraction function can be used. The abstraction is often a domain abstraction of the state variables that requires many proof obligations to be discharged, which can be very time-consuming for real applications. This paper presents a contribution to this problem that complements an approach based on domain abstraction for test generation, by adding a preliminary syntactic abstraction phase, based on variable elimination. We define a syntactic transformation that suppresses some variables from a B event model, in addition to three methods that choose relevant variables according to a test purpose. In this way, we propose a method that computes an abstraction of a source model {\mathsf{M}} according to a set of selected relevant variables. Depending on the method used, the abstraction can be computed as a simulation or as a bisimulation of {\mathsf{M}}. With this approach, the abstraction process produces a finite state system. We apply this abstraction computation to a model-based testing process. We evaluate experimentally the impact of the model simplification by variables' elimination on the size of the models, on the number of proof obligations to discharge, on the precision of the abstraction and on the coverage achieved by the test generation
- …